﻿#region Header
//************************************************************************************
// Name: CommonUtils
// Description: CommonUtils
// Created On:  02-Aug-2011
// Created By:  Swathi
// Last Modified On:
// Last Modified By:
// Last Modified Reason:
//*************************************************************************************
#endregion Header
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.IO;
using System.Media;
using System.Net;
using System.Net.Cache;
using System.Reflection;
using System.Security;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;
using System.Web.Caching;
using System.Web.Configuration;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Xml;
using Spring.Expressions;
using Spring.Core.IO;
using Spring.Context;
using Spring.Context.Support;
using System.IO;

namespace Base.Utils
{
    /// <summary>
    /// 本システムで共通の関数を定義する。（インスタンス化不可）
    /// </summary>
    /// <remarks>
    /// <para>このクラスはスタティックメソッドのみの実装としインスタンス化不可能とします。</para>
    /// <para>システムで共通で利用されるシステム関連関数を定義します。</para>
    /// </remarks>
    /// <example>
    /// 以下に使用例を示す。
    /// <code>
    ///   string work = "10.12";
    ///   // 文字列実数かどうか判定する。
    ///   if (CommonUtils.IsFloat(work))
    ///   {
    ///      // 文字列実数型だった場合の処理
    ///      double ExNum = double.Parse(work, CultureInfo.InvariantCulture);
    ///   }
    /// </code>
    /// </example>
    public sealed class CommonUtils
    {
        #region Fields

        /// <summary>
        /// Shift_JIS用文字列エンコーディング
        /// </summary>
        private static readonly Encoding sjisEnc = Encoding.GetEncoding(@"Shift_JIS");

        private static Uri _AbsoluteWebRoot;

        #endregion Fields

        #region Constructors

        /// <summary>
        /// インスタンス化を防ぐためのコンストラクタ
        /// </summary>
        /// <remarks>
        /// <para>このクラスはインスタンス化しないで利用する。</para>
        /// </remarks>
        /// <example>
        /// 以下に使用例を示す。
        /// <code>
        ///    string setting = CommonUtils.OracleDBSid;
        /// </code>
        /// </example>
        /// <exception cref="InvalidOperationException"></exception>
        private CommonUtils()
        {
            throw new InvalidOperationException("CommonUtilsはインスタンス化出来ません。");
        }

        #endregion Constructors

        #region Properties

        /// <summary>
        /// Webサイトのルート取得(絶対パス)
        /// </summary>
        /// <value>ルート</value>
        public static Uri AbsoluteWebRoot
        {
            get
            {
                if (_AbsoluteWebRoot == null)
                {
                    HttpContext context = HttpContext.Current;
                    if (context == null)
                        throw new WebException("The current HttpContext is null");

                    _AbsoluteWebRoot =
                        new Uri(context.Request.Url.Scheme + "://" + context.Request.Url.Authority + RelativeWebRoot);
                }
                return _AbsoluteWebRoot;
            }
        }

        /// <summary>
        /// Webサイトのルート取得(相対パス)
        /// </summary>
        /// <value>ルート</value>
        public static string RelativeWebRoot
        {
            get { return VirtualPathUtility.ToAbsolute("~/"); }
        }

        /// <summary>
        /// Shift_JIS用文字列エンコーディングを返却します
        /// </summary>
        public static Encoding ShiftJisEncoding
        {
            get { return sjisEnc; }
        }

        /// <summary>
        /// Windowsディレクトリパスの取得
        /// </summary>
        /// <returns>Windowsディレクトリパス名文字列(後ろ\付)</returns>
        public static string WindowsDirectory
        {
            get
            {
                // Windows ディレクトリのパスを取得する。
                string winPath = Environment.ExpandEnvironmentVariables("%windir%").Trim() +
                                 Path.DirectorySeparatorChar;
                return winPath;
            }
        }

        /// <summary>
        /// Windows Systemディレクトリパスの取得
        /// </summary>
        /// <returns>Windows Systemディレクトリパス名文字列(後ろ\付)</returns>
        public static string WindowsSystemDirectory
        {
            get
            {
                // Windows ディレクトリのパスを取得する。
                string winPath = Environment.SystemDirectory +
                                 Path.DirectorySeparatorChar;
                return winPath;
            }
        }

        #endregion Properties

        #region Methods

        /// <summary>
        /// 整数符号付け処理
        /// </summary>
        /// <remarks>
        ///
        /// </remarks>
        /// <param name="value">数値</param>
        /// <param name="addFugo">符号文字<para>"-"</para><para>"+"</para></param>
        /// <returns>符号付き数値</returns>
        public static int AddFugoInt(int value, string addFugo)
        {
            int result;
            if (addFugo == "-")
            {
                result = checked(-1*value);
            }
            else
            {
                result = value;
            }
            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="dd"></param>
        /// <param name="elementName"></param>
        /// <param name="nodeNameValue"></param>
        /// <param name="nodeNameText"></param>
        /// <param name="xmlPath"></param>
        public static void BindDropDown(DropDownList dd, string elementName, string nodeNameValue, string nodeNameText,
                                        string xmlPath)
        {
            HttpContext context = HttpContext.Current;
            XmlTextReader reader = null;
            var lstItems = new ArrayList();
            string val = string.Empty;
            string txt = string.Empty;
            bool inTarget = false;
            try
            {
                reader = new XmlTextReader(xmlPath);
                //Allow for object to object comparison rather than string comparison
                object target = reader.NameTable.Add(elementName);
                object targetVal = reader.NameTable.Add(nodeNameValue);
                object targetTxt = reader.NameTable.Add(nodeNameText);
                //Read through the XML stream and find proper tokens
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        //Check attribute names
                        if (reader.Name.Equals(target))
                        {
                            inTarget = true;
                            //Get attribute values (if any)
                            if (reader.HasAttributes)
                            {
                                if (reader.MoveToAttribute(nodeNameValue))
                                {
                                    val = reader.Value;
                                    reader.MoveToElement();
                                }
                                if (reader.MoveToAttribute(nodeNameText))
                                {
                                    txt = reader.Value;
                                    reader.MoveToElement();
                                }
                            }
                            if (val == "" | txt == "")
                            {
                                val = txt = string.Empty;
                            }
                            if (val != string.Empty & txt != string.Empty)
                            {
                                var item = new ListItem(txt, val);
                                lstItems.Add(item);
                                //Attribute values override any child nodes values
                                //so if we match on attributes then don't look at any
                                //child nodes
                                inTarget = false;
                                val = txt = string.Empty;
                            }
                        }
                        else if (inTarget)
                        {
                            //Check for child nodes that match
                            if (reader.Name.Equals(targetVal))
                            {
                                val = reader.ReadString();
                                if (val == "")
                                {
                                    val = string.Empty;
                                }
                            }
                            if (reader.Name.Equals(targetTxt))
                            {
                                txt = reader.ReadString();
                                if (txt == "")
                                {
                                    txt = string.Empty;
                                }
                            }
                            if (val != string.Empty & txt != string.Empty)
                            {
                                var item = new ListItem(txt, val);
                                lstItems.Add(item);
                                val = txt = string.Empty;
                            }
                        }
                    }
                    if (reader.NodeType == XmlNodeType.EndElement | reader.IsEmptyElement)
                    {
                        if (reader.Name.Equals(target))
                        {
                            inTarget = false;
                        }
                    }
                }
                if (lstItems.Count > 0)
                {
                    foreach (ListItem item in lstItems)
                    {
                        dd.Items.Add(item);
                    }
                }
                else
                {
                    var item = new ListItem("No Data Available", "");
                    dd.Items.Add(item);
                }
                lstItems.Clear();
            }
            catch (Exception exp)
            {
                throw exp;
            }
            finally
            {
                if ((reader != null))
                {
                    reader.Close();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ll"></param>
        /// <param name="elementName"></param>
        /// <param name="nodeNameValue"></param>
        /// <param name="nodeNameText"></param>
        /// <param name="xmlPath"></param>
        public static void BindListBox(ListBox ll, string elementName, string nodeNameValue, string nodeNameText,
                                       string xmlPath)
        {
            HttpContext context = HttpContext.Current;
            XmlTextReader reader = null;
            var lstItems = new ArrayList();
            string val = string.Empty;
            string txt = string.Empty;
            bool inTarget = false;
            try
            {
                reader = new XmlTextReader(xmlPath);
                //Allow for object to object comparison rather than string comparison
                object target = reader.NameTable.Add(elementName);
                object targetVal = reader.NameTable.Add(nodeNameValue);
                object targetTxt = reader.NameTable.Add(nodeNameText);
                //Read through the XML stream and find proper tokens
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        //Check attribute names
                        if (reader.Name.Equals(target))
                        {
                            inTarget = true;
                            //Get attribute values (if any)
                            if (reader.HasAttributes)
                            {
                                if (reader.MoveToAttribute(nodeNameValue))
                                {
                                    val = reader.Value;
                                    reader.MoveToElement();
                                }
                                if (reader.MoveToAttribute(nodeNameText))
                                {
                                    txt = reader.Value;
                                    reader.MoveToElement();
                                }
                            }
                            if (val == "" | txt == "")
                            {
                                val = txt = string.Empty;
                            }
                            if (val != string.Empty & txt != string.Empty)
                            {
                                var item = new ListItem(txt, val);
                                lstItems.Add(item);
                                //Attribute values override any child nodes values
                                //so if we match on attributes then don't look at any
                                //child nodes
                                inTarget = false;
                                val = txt = string.Empty;
                            }
                        }
                        else if (inTarget)
                        {
                            //Check for child nodes that match
                            if (reader.Name.Equals(targetVal))
                            {
                                val = reader.ReadString();
                                if (val == "")
                                {
                                    val = string.Empty;
                                }
                            }
                            if (reader.Name.Equals(targetTxt))
                            {
                                txt = reader.ReadString();
                                if (txt == "")
                                {
                                    txt = string.Empty;
                                }
                            }
                            if (val != string.Empty & txt != string.Empty)
                            {
                                var item = new ListItem(txt, val);
                                lstItems.Add(item);
                                val = txt = string.Empty;
                            }
                        }
                    }
                    if (reader.NodeType == XmlNodeType.EndElement | reader.IsEmptyElement)
                    {
                        if (reader.Name.Equals(target))
                        {
                            inTarget = false;
                        }
                    }
                }
                if (lstItems.Count > 0)
                {
                    foreach (ListItem item in lstItems)
                    {
                        ll.Items.Add(item);
                    }
                }
                else
                {
                    var item = new ListItem("No Data Available", "");
                    ll.Items.Add(item);
                }
                lstItems.Clear();
            }
            catch (Exception exp)
            {
                throw exp;
            }
            finally
            {
                if ((reader != null))
                {
                    reader.Close();
                }
            }
        }

        /// <summary>
        /// ビット値を２進文字列に変換する処理
        /// </summary>
        /// <remarks>
        ///
        /// </remarks>
        /// <param name="bitValue">ビット値</param>
        /// <param name="outLength">出力２進文字列桁数</param>
        /// <param name="isSpaceInsert">４桁ごとにｽﾍﾟｰｽ挿入判定（省略可能：ﾃﾞﾌｫﾙﾄ値-False）</param>
        /// <returns>変換文字列（例：'00010010'）</returns>
        public static string BitToStr(uint bitValue, int outLength, bool isSpaceInsert)
        {
            string result;
            // ｽﾍﾟｰｽ区切り桁数
            const int intS_Cnt = 4;
            // カウンタ
            int intCnt;
            // ワークフィルタ
            uint wrdBuf;

            result = "";
            wrdBuf = 1;
            var digits = new StringBuilder();
            int endLength = Math.Min(16, outLength);
            for (intCnt = 1; intCnt <= endLength; intCnt++)
            {
                // 文字列作成
                if ((wrdBuf & bitValue) > 0)
                {
                    digits.Insert(0, '1');
                }
                else
                {
                    digits.Insert(0, '0');
                }
                // ｽﾍﾟｰｽ挿入
                if (isSpaceInsert && ((intCnt%intS_Cnt) == 0))
                {
                    digits.Insert(0, ' ');
                }
                // ﾌｨﾙﾀ設定
                wrdBuf <<= 1;
            }
            result = digits.ToString().Trim();
            return result;
        }

        /// <summary>
        /// Function to calculate the BMi based on height and weight
        /// </summary>
        /// <param name="weight">Weight in lbs</param>
        /// <param name="height">Height in the format 5.2 i.e. 5 ft and 2 inches or 5 which is 5 ft</param>
        /// <returns></returns>
        public static double CalcBMI(double weight, double height)
        {
            double retVal = 0.0;

            if (height != 0.0)
            {
                //Convert the height into inches
                //double heightInInches = (Convert.ToInt32(height) * 12) + ((height - Convert.ToInt32(height)) * 100);

                //modified by asma on Aug 02
                //Reason:convert height to inchs
                string[] arheight = CnvStr(height).Split('.');
                double heightInInches;
                if (arheight.Length == 2)
                    heightInInches = (StrToInt(arheight[0])*12) + (StrToInt(arheight[1]));
                else if (arheight.Length == 1)
                    heightInInches = (StrToInt(arheight[0])*12);
                else
                    heightInInches = 0;
                //End of modification

                //Calculate the BMI
                retVal = (weight*703)/(heightInInches*heightInInches);

                //returns the rounded of value
                retVal = Math.Round(retVal, 1);
            }

            return retVal;
        }

        /// <summary>
        /// 文字列変換
        /// 対象がNULLの場合は、空値を返します
        /// </summary>
        /// <param name="target">変換元オブジェクト</param>
        /// <returns>変換後文字列</returns>
        public static string CnvStr(object target)
        {
            if (target == null)
            {
                return string.Empty;
            }
            if (target == DBNull.Value)
            {
                return string.Empty;
            }
            try
            {
                string ret = target.ToString();
                return ConvProperString(ret);
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }

        public static ArrayList CodeAssemblies()
        {
            var codeAssemblies = new ArrayList();
            CompilationSection s = null;
            try
            {
                string assemblyName = "__code";
                try
                {
                    s = (CompilationSection) WebConfigurationManager.GetSection("system.web/compilation");
                }
                catch (SecurityException)
                {
                    // No read permissions on web.config due to the trust level (must be High or Full)
                }

                if (s != null && s.CodeSubDirectories != null && s.CodeSubDirectories.Count > 0)
                {
                    for (int i = 0; i < s.CodeSubDirectories.Count; i++)
                    {
                        assemblyName = "App_SubCode_" + s.CodeSubDirectories[i].DirectoryName;
                        codeAssemblies.Add(Assembly.Load(assemblyName));
                    }
                }
                else
                {
                    Type t = Type.GetType("Mono.Runtime");
                    if (t != null) assemblyName = "App_Code";
                    codeAssemblies.Add(Assembly.Load(assemblyName));
                }
            }
            catch (FileNotFoundException)
            {
/*ignore - code directory has no files*/
            }

            return codeAssemblies;
        }

        /// <summary>
        /// Replaces single quote with two single quotes and also preserves Leading and Trailing spaces [indentations]
        /// </summary>
        /// <param name="input">string</param>
        /// <returns>string</returns>
        public static string ConvProperString(string input)
        {
            string wk = string.Empty;
            wk = Regex.Replace(input, @"^(?<1>\r\n)*(?<3>.*?)\s*$", @"$3", RegexOptions.Multiline);
            return wk;
        }

        /// <summary>
        /// 相対Webルートパスを絶対Webルートパスに変換
        /// </summary>
        /// <param name="target">相対Webルートパス</param>
        /// <value>絶対Webルートパス</value>
        public static Uri ConvertToAbsolute(Uri relativeUri)
        {
            if (relativeUri == null)
                throw new ArgumentNullException("relativeUri");

            string absolute = AbsoluteWebRoot.ToString();
            int index = absolute.LastIndexOf(RelativeWebRoot);

            return new Uri(absolute.Substring(0, index) + relativeUri);
        }

        /// <summary>
        /// 数値符号分割処理
        /// </summary>
        /// <remarks>
        /// <para>引き渡された数値の符号を確認して符号文字列及び絶対値を返却する。</para>
        /// </remarks>
        /// <param name="value">
        /// <para>数値 (正の整数に変換)</para>
        /// <para>絶対値がセットされる。</para>
        /// </param>
        /// <returns>
        /// <para>符号（"+"／"-"）文字列</para>
        /// <para>引き渡された数値には、絶対値をセットして返却する。</para>
        /// <para>戻り値には、プラス／マイナス文字列が設定される。</para>
        /// </returns>
        public static string DivisionFugoAndValue(ref int value)
        {
            string result;

            if (value < 0)
            {
                value *= -1;
                result = @"-";
            }
            else
            {
                result = @"+";
            }
            return result;
        }

        /// <summary>
        /// 指定文字列を指定数連結する処理
        /// </summary>
        /// <remarks>
        ///
        /// </remarks>
        /// <param name="appendValue">結合する文字列</param>
        /// <param name="count">結合数</param>
        /// <returns>結合後文字列</returns>
        public static string FillString(string appendValue, int count)
        {
            string result;
            var digits = new StringBuilder();
            for (int i = 0; i < count; i++)
            {
                digits.Append(appendValue);
            }
            result = digits.ToString();
            return result;
        }

        /// <summary>
        /// 文字列置換
        /// 文字列の前後に'を付加(SQL用)
        /// </summary>
        /// <param name="target">変換前文字列</param>
        /// <value>変換後文字列</value>
        public static string GetAsDBString(string input)
        {
            string result;
            result = string.IsNullOrEmpty(input) ? "" : input.Replace("'", "''");
            return "'" + result + "'";
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="control"></param>
        /// <param name="propName">editorID</param>
        /// <returns></returns>
        public static string GetClientID(Control control, string propName)
        {
            string result = string.Empty;
            Type t = control.GetType();
            PropertyInfo[] props = t.GetProperties(BindingFlags.NonPublic | BindingFlags.Instance);

            foreach (PropertyInfo prop in props)
            {
                if (prop.Name.ToLower().Equals(propName))
                {
                    result = prop.GetValue(control, null).ToString();
                    break;
                }
            }
            return result;
        }

        /// <summary>
        /// Returns Directory / Drive Name from Full/partial file path
        /// </summary>
        /// <example>
        /// 
        /// \\win2003	            ＝＞＞		\\win2003
        /// \\win2003\	            ＝＞＞		\\win2003
        /// \\win2003\test.txt	    ＝＞＞		\\win2003
        /// \\win2003\test	        ＝＞＞		\\win2003\test
        /// \\win2003\test\	        ＝＞＞		\\win2003\test
        /// \\win2003\test\test.txt	＝＞＞		\\win2003\test
        /// C:	                    ＝＞＞		C:
        /// C:\	                    ＝＞＞		C:
        /// C:\test.txt	            ＝＞＞		C:
        /// C:\test	                ＝＞＞		C:\test
        /// C:\test\	            ＝＞＞		C:\test
        /// C:\test\test.txt	    ＝＞＞		C:\test
        /// </example>
        /// <param name="path"></param>
        /// <returns>Directory/Drive Name as string</returns>
        public static string GetDirectoryName(string path)
        {
            string result = string.Empty;
            string tempFname = string.Empty;
            try
            {
                if (path.Length >= 5)
                {
                    //+*+FileName
                    tempFname = Path.GetFileName(path);
                    if (!string.IsNullOrEmpty(tempFname))
                    {
                        //if (tempFname.Substring(tempFname.Length - 4, 1).Equals(".")) //+*+Valid File Name
                        if (!string.IsNullOrEmpty(Path.GetExtension(tempFname))) //+*+Valid File Name
                        {
                            //Get Directory Name
                            result = Path.GetDirectoryName(path);
                            if (result == null) //+*+Result will be null if path is like \\win2003\test.txt
                                result = path.Replace(tempFname, "");
                        }
                        else //+*+In Valid File Name
                        {
                            result = path;
                        }
                    }
                    else //+*+ No File Name in the path
                    {
                        result = path;
                    }
                }
                else //May be Only Root Folder i.e. C:\ [or] \\FL
                {
                    result = path;
                }

                //+*+ Remove Last "\" if one exists
                if (result.Substring(result.Length - 1, 1).Equals(@"\"))
                {
                    result = result.Substring(0, result.Length - 1);
                }
            }
            catch (Exception)
            {
                throw;
            }

            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public static Hashtable GetEmailContents()
        {
            if (HttpRuntime.Cache["emailTemplate.xml"] == null)
            {
                var oDs = new DataSet();
                oDs.ReadXml(HttpContext.Current.Server.MapPath("~/xml/emailTemplate.xml"));
                var ht = new Hashtable();

                foreach (DataRow dataRow in oDs.Tables[0].Rows)
                {
                    ht.Add(CnvStr(dataRow["id"]), CnvStr(dataRow["name"]));
                }
                HttpRuntime.Cache.Insert("emailTemplate.xml", ht,
                                         new CacheDependency(
                                             HttpContext.Current.Server.MapPath(("~/xml/emailTemplate.xml"))));
            }

            return HttpRuntime.Cache["emailTemplate.xml"] as Hashtable;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public static NumberFormatInfo GetNumberFormatInfo()
        {
            var a = new NumberFormatInfo();
            a.NumberGroupSeparator = string.Empty;
            return a;
        }

        /// <summary>
        /// ランダム番号文字列の取得
        /// </summary>
        /// <param name="num"></param>
        /// <returns></returns>
        public static String GetRandom(int num)
        {
            if (num < 1) throw new ArgumentOutOfRangeException("num", "１以上の数値を指定してください。");
            var randoms = new byte[num + 1];

            var rng = new RNGCryptoServiceProvider();
            // ランダム番号の生成
            rng.GetBytes(randoms);

            var inputNumber = new StringBuilder();
            for (int i = 0; i < num; i++)
            {
                inputNumber.Append((randoms[i]%10).ToString());
            }
            return inputNumber.ToString();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="fileUrl"></param>
        /// <returns></returns>
        public static Byte[] HttpFileDownLoad(string fileUrl)
        {
            try
            {
                //+*+Set No Cache
                var noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
                WebRequest request = WebRequest.Create(fileUrl);
                //+*+Set No Cache For this Current Request
                request.CachePolicy = noCachePolicy;
                //+*+Use credentials of the currently logged on user
                request.Credentials = CredentialCache.DefaultCredentials;

                WebResponse response = request.GetResponse();
                Stream stream = response.GetResponseStream();
                long length = response.ContentLength;
                var bytes = new byte[length + 1];
                for (int i = 0; i <= length - 1; i++)
                {
                    bytes[i] = (byte) stream.ReadByte();
                }
                return bytes;

              
            }
            catch (WebException wex)
            {
                switch (wex.Status)
                {
                    case WebExceptionStatus.ProtocolError:
                    case WebExceptionStatus.ReceiveFailure:
                    case WebExceptionStatus.ServerProtocolViolation:
                        throw new FileNotFoundException(fileUrl + "ファイルが存在しません。");
                    case WebExceptionStatus.NameResolutionFailure:
                        throw new FileNotFoundException(fileUrl + "名前解決サービスがホスト名を解決できませんでした。");
                    case WebExceptionStatus.ProxyNameResolutionFailure:
                        throw new FileNotFoundException(fileUrl + "名前解決サービスがプロキシ ホスト名を解決できませんでした。");
                    default:
                        throw;
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// 整数型 → 実数型変換処理
        /// </summary>
        /// <remarks>
        ///
        /// </remarks>
        /// <param name="value">整数型数値</param>
        /// <returns>Double型数値</returns>
        public static double IntToFloat(int value)
        {
            double result;
            result = Convert.ToSingle((value).ToString());
            return result;
        }

        /// <summary>
        /// 文字列実数判定処理(double)
        /// </summary>
        /// <remarks>
        /// <para>実際の判定はdouble型で判定</para>
        /// <para>float ±1.5 × 10 - 45 ～ ±3.4 × 1038　7 桁</para>
        /// <para>double ±5.0 × 10 - 324 ～ ±1.7 × 10308　15 ～ 16 桁</para>
        /// </remarks>
        /// <param name="value">判定したい文字列</param>
        /// <returns>True：実数 ／ False：実数でない</returns>
        /// <example>
        /// 以下に使用例を示す。
        /// <code>
        ///   string work = "10.12";
        ///   // 文字列実数かどうか判定する。
        ///   if (CommonUtils.IsFloat(work))
        ///   {
        ///      // 文字列実数型だった場合の処理
        ///      double ExNum = double.Parse(work, CultureInfo.InvariantCulture);
        ///   }
        /// </code>
        /// </example>
        public static bool IsFloat(string value)
        {
            if (String.IsNullOrEmpty(value))
            {
                return false;
            }
            bool result = false;
            double exNum;
            result = double.TryParse(value, out exNum);
            return result;
        }

        /// <summary>
        /// 文字列整数判定処理(Int64)
        /// </summary>
        /// <remarks>
        /// <para>実際の判定はInt64で実行(符号付き 64 ビット整数)して判定する。</para>
        /// <para>-9,223,372,036,854,775,808 ～ 9,223,372,036,854,775,807</para>
        /// </remarks>
        /// <param name="value">判定したい文字列</param>
        /// <returns>True：整数 ／ False：整数でない</returns>
        /// <example>
        /// 以下に使用例を示す。
        /// <code>
        ///   string work = "-11928374";
        ///   // 文字列整数かどうか判定する。
        ///   if (CommonUtils.IsInt(work))
        ///   {
        ///      // 文字列整数だった場合の処理
        ///      long ExNum = long.Parse(work, CultureInfo.InvariantCulture);
        ///   }
        /// </code>
        /// </example>
        public static bool IsInt(string value)
        {
            if (String.IsNullOrEmpty(value))
            {
                return false;
            }
            bool result = false;
            Int64 exNum;
            result = Int64.TryParse(value, out exNum);
            return result;
        }

        /// <summary>
        /// 文字列数値判定処理
        /// </summary>
        /// <remarks>
        /// <para>実際の判定はdouble型で判定</para>
        /// <para>double ±5.0 × 10 - 324 ～ ±1.7 × 10308　15 ～ 16 桁</para>
        /// </remarks>
        /// <param name="value">判定したい文字列</param>
        /// <returns>true：数値 ／ false：数値でない</returns>
        /// <example>
        /// 以下に使用例を示す。
        /// <code>
        ///   string work = "-10.3";
        ///   // 文字列数値かどうか判定する。
        ///   if (CommonUtils.IsNumeric(work))
        ///   {
        ///      // 文字列数値だった場合の処理
        ///      double ExNum = double.Parse(work, CultureInfo.InvariantCulture);
        ///   }
        /// </code>
        /// </example>
        public static bool IsNumeric(string value)
        {
            if (String.IsNullOrEmpty(value))
            {
                return false;
            }
            bool result = false;
            double exNum;
            result = double.TryParse(value, out exNum);
            return result;
        }

        /// <summary>
        /// 文字列数値判定処理
        /// </summary>
        /// <remarks>
        /// <para>実際の判定はdouble型で判定</para>
        /// <para>double ±5.0 × 10 - 324 ～ ±1.7 × 10308　15 ～ 16 桁</para>
        /// </remarks>
        /// <param name="value">判定したい文字</param>
        /// <returns>true：数値 ／ false：数値でない</returns>
        /// <example>
        /// 以下に使用例を示す。
        /// <code>
        ///   char work = '3';
        ///   // 文字列数値かどうか判定する。
        ///   if (CommonUtils.IsNumeric(work))
        ///   {
        ///      // 文字列数値だった場合の処理
        ///      double ExNum = double.Parse(work, CultureInfo.InvariantCulture);
        ///   }
        /// </code>
        /// </example>
        public static bool IsNumeric(char value)
        {
            bool result = false;
            double exNum;
            result = double.TryParse(value.ToString(), out exNum);
            return result;
        }

        /// <summary>
        /// 文字列から長さを取得し返します。
        /// </summary>
        /// <param name="targetString">対象文字列</param>
        /// <remarks>
        /// VB6のLenB類似メソッド
        /// Shift-JISに文字を変換し、文字列を返す
        /// </remarks>
        /// <returns>文字長</returns>
        public static int LenB(string targetString)
        {
            int functionReturnValue = 0;
            functionReturnValue = 0;
            //Shift JISに変換したときに必要なバイト数を返す
            try
            {
                functionReturnValue = Encoding.GetEncoding(932).GetByteCount(targetString);
            }
            catch (Exception)
            {
                throw;
            }
            return functionReturnValue;
        }

        /// <summary>
        /// 文字列から指定された文字数分の文字列を返します。
        /// </summary>
        /// <param name="targetString">対象文字列</param>
        /// <param name="StartPos">切り取り位置</param>
        /// <param name="Length">バイト数（文字列長）</param>
        /// <remarks>
        /// VB6のMibB類似メソッド
        /// Shift-JISに文字を変換し、文字列を抜き出し返す
        /// </remarks>
        /// <returns>文字長</returns>
        public static string MidB(string targetString, int StartPos, int Length)
        {
            try
            {
                if (targetString == "")
                    return "";

                if (Length < 0)
                {
                    Length = LenB(targetString) - StartPos + 1;
                }

                //Shift JISとして文字列に変換
                byte[] bytesData = Encoding.GetEncoding(932).GetBytes(targetString);

                int i = 0;
                int j = 0;
                var makedBytes = new byte[Length];

                int lastLen = (StartPos - 1) + (Length - 1);
                if (lastLen > bytesData.Length)
                {
                    lastLen = bytesData.Length - 1;
                }

                for (i = (StartPos - 1); i <= lastLen; i++)
                {
                    makedBytes[j] = bytesData[i];
                    j += 1;
                }

                //文字列に変換
                //Shift JISとして文字列に変換
                string str = Encoding.GetEncoding(932).GetString(makedBytes);
                return str;
            }

            catch (Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// .wavファイル再生
        /// </summary>
        /// <param name="wavFileName">再生対象ファイル</param>
        public static void PlayWavFile(string wavFileName)
        {
            if (!File.Exists(wavFileName))
            {
                throw new FileNotFoundException("再生ファイルが見つかりません。( ファイル名：" + wavFileName + " )");
            }

            using (var sp = new SoundPlayer())
            {
                sp.SoundLocation = wavFileName;
                sp.Play();
            }
        }

        public static string ReplaceDotNetCRLFWithJavaScriptLF(string input)
        {
            // Damn pesky carriage returns...
            input = input.Replace("\r\n", "\n");
            input = input.Replace("\r", "\n");
            input = input.Replace("\n", "\\n");
            return input;
        }

        /// <summary>
        /// 整数値文字列をStrToBoolean値に変換する。(変換できない場合には0に設定する)
        /// <para>StrToIntDef -> StrToInt に変更</para>
        /// </summary>
        /// <remarks>
        /// <para>整数値文字列を整数値に変換する処理</para>
        /// <para>変換できない場合には 設定されたデフォルト値 に変換されます。</para>
        /// </remarks>
        /// <param name="value">変換文字列</param>
        /// <returns>変換数値</returns>
        /// <example>
        /// 以下に使用例を示す。
        /// <code>
        ///   int work = CommonUtils.StrToInt("10");
        /// </code>
        /// </example>
        public static Boolean StrToBoolean(string value)
        {
            return StrToBoolean(value, false);
        }

        /// <summary>
        /// 整数値文字列をBoolean値に変換する。(変換できない場合にはデフォルト値に設定する)
        /// <para>StrToIntDef -> StrToInt に変更</para>
        /// </summary>
        /// <remarks>
        /// <para>整数値文字列を整数値に変換する処理</para>
        /// <para>変換できない場合には 設定されたデフォルト値 に変換されます。</para>
        /// </remarks>
        /// <param name="value">変換文字列</param>
        /// <param name="defaultData">デフォルト値</param>
        /// <returns>変換数値</returns>
        /// <example>
        /// 以下に使用例を示す。
        /// <code>
        ///   int work = CommonUtils.StrToInt("10", 1);
        /// </code>
        /// </example>
        public static Boolean StrToBoolean(string value, Boolean defaultData)
        {
            Boolean result;
            if (!Boolean.TryParse(value, out result))
            {
                // 変換できなかった場合（２次変換）
                // int変換してみる
                int intdata;
                if (Int32.TryParse(value, out intdata))
                {
                    // int変換に成功した場合は、0 以外は trueに設定
                    result = (intdata != 0);
                }
                else
                {
                    result = defaultData;
                }
            }
            return result;
        }

        public static DateTime StrToDateTime(string value)
        {
            //TODO: Optimize the code below and include Try catch
            var colMonths = new List<string>();
            colMonths.Add("jan");
            colMonths.Add("feb");
            colMonths.Add("mar");
            colMonths.Add("apr");
            colMonths.Add("may");
            colMonths.Add("jun");
            colMonths.Add("jul");
            colMonths.Add("aug");
            colMonths.Add("sep");
            colMonths.Add("oct");
            colMonths.Add("nov");
            colMonths.Add("dec");

            string inputDate = value.Replace("-", "/").ToLower();
            inputDate = inputDate.Replace(inputDate.Split('/')[1].ToLower(),
                                          (colMonths.IndexOf(inputDate.Split('/')[1].ToLower()) + 1).ToString().PadLeft(
                                              2, '0'));
            //TODO ends
            if (string.IsNullOrEmpty(value))
            {
                inputDate = "01/01/1970";
            }

            DateTime MyDateTime;
            MyDateTime = new DateTime();
            if (!string.IsNullOrEmpty(inputDate))
            {
                try
                {
                    MyDateTime = DateTime.ParseExact(inputDate, "dd/MM/yyyy", null);
                }
                catch
                {
                    MyDateTime = DateTime.ParseExact("01/01/1970", "dd/MM/yyyy", null);
                }
            }
            return MyDateTime;
        }

        /// <summary>
        /// 整数値文字列を整数(Decimal)値に変換する。(変換できない場合には0に設定する)
        /// <para>StrToIntDef -> StrToInt に変更</para>
        /// </summary>
        /// <remarks>
        /// <para>整数値文字列を整数値に変換する処理</para>
        /// <para>変換できない場合には 設定されたデフォルト値 に変換されます。</para>
        /// </remarks>
        /// <param name="value">変換文字列</param>
        /// <returns>変換数値</returns>
        /// <example>
        /// 以下に使用例を示す。
        /// <code>
        ///   int work = CommonUtils.StrToInt("10");
        /// </code>
        /// </example>
        public static Decimal StrToDecimal(string value)
        {
            return StrToDecimal(value, 0);
        }

        /// <summary>
        /// 整数値文字列を整数(Decimal)値に変換する。(変換できない場合にはデフォルト値に設定する)
        /// <para>StrToIntDef -> StrToInt に変更</para>
        /// </summary>
        /// <remarks>
        /// <para>整数値文字列を整数値に変換する処理</para>
        /// <para>変換できない場合には 設定されたデフォルト値 に変換されます。</para>
        /// </remarks>
        /// <param name="value">変換文字列</param>
        /// <param name="defaultData">デフォルト値</param>
        /// <returns>変換数値</returns>
        /// <example>
        /// 以下に使用例を示す。
        /// <code>
        ///   int work = CommonUtils.StrToInt("10", 1);
        /// </code>
        /// </example>
        public static Decimal StrToDecimal(string value, Decimal defaultData)
        {
            Decimal result;
            if (!Decimal.TryParse(value, out result))
            {
                // 変換できなかった場合
                result = defaultData;
            }
            return result;
        }

        public static Double StrToDouble(string value)
        {
            return StrToDouble(value, 0);
        }

        public static Double StrToDouble(string value, Double defaultData)
        {
            Double result;
            if (!Double.TryParse(value, out result))
            {
                // 変換できなかった場合
                result = defaultData;
            }
            return result;
        }

        /// <summary>
        /// 整数値文字列を整数値に変換する。（変換できない場合には 0 に変換）
        /// <para>StoIz -> StrToInt に変更</para>
        /// </summary>
        /// <remarks>
        /// <para>整数値文字列を整数値に変換する処理</para>
        /// <para>変換できない場合には 0 に変換されます。</para>
        /// </remarks>
        /// <param name="value">変換文字列</param>
        /// <returns>変換数値</returns>
        /// <example>
        /// 以下に使用例を示す。
        /// <code>
        ///   int work = CommonUtils.StrToInt("10");
        /// </code>
        /// </example>
        public static int StrToInt(string value)
        {
            return StrToInt(value, 0);
        }

        /// <summary>
        /// 整数値文字列を整数(Int32)値に変換する。(変換できない場合にはデフォルト値に設定する)
        /// <para>StrToIntDef -> StrToInt に変更</para>
        /// </summary>
        /// <remarks>
        /// <para>整数値文字列を整数値に変換する処理</para>
        /// <para>変換できない場合には 設定されたデフォルト値 に変換されます。</para>
        /// </remarks>
        /// <param name="value">変換文字列</param>
        /// <param name="defaultData">デフォルト値</param>
        /// <returns>変換数値</returns>
        /// <example>
        /// 以下に使用例を示す。
        /// <code>
        ///   int work = CommonUtils.StrToInt("10", 1);
        /// </code>
        /// </example>
        public static int StrToInt(string value, int defaultData)
        {
            int result;
            if (!Int32.TryParse(value, out result))
            {
                // 変換できなかった場合
                result = defaultData;
            }
            return result;
        }

        /// <summary>
        /// 整数値文字列を整数（Long）値に変換する。（変換できない場合は0を返す）
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static long StrToLong(string value)
        {
            try
            {
                long result;
                if (!long.TryParse(value, out result))
                {
                    // 変換できなかった場合
                    result = 0;
                }
                return result;
            }
            catch (Exception)
            {
                return 0;
            }
        }

        /// <summary>
        /// 整数値文字列を整数（Short）値に変換する。（変換できない場合は0を返す）
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static short StrToShort(string value)
        {
            try
            {
                short result;
                if (!short.TryParse(value, out result))
                {
                    // 変換できなかった場合
                    result = 0;
                }
                return result;
            }
            catch (Exception)
            {
                return 0;
            }
        }

        public static string GetDateAsDDMMMYYYY()
        {
            return DateTime.Now.ToString("ddMMMyyyy").ToLower();
        }

        public static string GetUnixDateTime()
        {
            return DateTime.Now.ToString("ddMMyyyyhhmmss").ToLower();
        }

        public static DateTime ConvertDatetoDBFormat(DateTime date)
        {
            DateTime outputDate = date;
            if (date.Year != 1900)
            {
                outputDate =
                    DateTime.ParseExact(
                        (date.Day.ToString().PadLeft(2, '0') + "/" + date.Month.ToString().PadLeft(2, '0') + "/" +
                         date.Year), "dd/MM/yyyy", null);
            }
            return outputDate;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="input"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static String StripString(string input, int length)
        {
            string result = string.Empty;
            if (!string.IsNullOrEmpty(input))
            {
                result = (input.Length <= length) ? input : input.Substring(0, length - 1) + "...";
            }
            return result;
        }

        public static char ConvertFBGenderToOneChar(string gender)
        {
            char outputGender = 'M';
            if (gender == "female")
                outputGender = 'F';
            return outputGender;
        }


        //Function to check whether tha date is equal to datetime.now or not
        //if it is equal  to datetime.now now pass the empty string
        public static string  CheckDateForMinValue(DateTime dtValue)
        {
            string returnDateValue = string.Empty;
            if (DateTime.MinValue != dtValue)
            {
                returnDateValue = dtValue.ToString("MM/dd/yyyy");
            }
            return returnDateValue;
               
        }

        public static string GetResourceAsString(string uri)
        {
          string result = string.Empty;
            try
            {
                IApplicationContext appContext = ContextRegistry.GetContext();
                IResource resource = appContext.GetResource(uri);
                StreamReader reader = new StreamReader(resource.InputStream);

                result = reader.ReadToEnd();
                reader.Close();
            }
            catch (Exception) { }
            return result;
        }

        public static byte[] GetFileAsByteArray(HttpPostedFile fileContent)
        {
            long length = fileContent.ContentLength;
            var bytes = new byte[length + 1];
            for (int i = 0; i <= length - 1; i++)
            {
                bytes[i] = (byte)fileContent.InputStream.ReadByte();
            }
            return bytes;

        }

        public static byte[] GetAsByteArray(Stream stream)
        {

            var bytes = new byte[stream.Length];
            stream.Read(bytes, 0, (int)stream.Length);
            return bytes;
        }

        #endregion Methods

        #region Other

        /////// <summary>
        /////// オラクルに接続するための SID 文字列
        /////// </summary>
        ////private static string oracleDBSid = StageStrings.OracleDBSid;
        /////// <summary>
        /////// オラクルに接続するための ユーザ名 文字列
        /////// </summary>
        ////private static string oracleDBUserName = StageStrings.OracleDBUserName;
        /////// <summary>
        /////// オラクルに接続するための パスワード 文字列
        /////// </summary>
        ////private static string oracleDBPassword = StageStrings.OracleDBPassword;

        #endregion Other

        #region DateTime
        
        static DateTime ConvertFromUnixTimestamp(double timestamp)
        {
            DateTime origin = new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return origin.AddSeconds(timestamp);
        }


        static double ConvertToUnixTimestamp(DateTime date)
        {
            DateTime origin = new DateTime(1970, 1, 1, 0, 0, 0, 0);
            TimeSpan diff = date - origin;
            return Math.Floor(diff.TotalSeconds);
        }
        #endregion DateTime
    }
}